home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / editors / emacs / xemacs / xemacs-1.004 / xemacs-1 / xemacs-19.13 / src / frame.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-08-31  |  67.5 KB  |  2,323 lines
  1. /* Generic frame functions.
  2.    Copyright (C) 1989, 1992, 1993, 1994 Free Software Foundation.
  3.    Copyright (C) 1995 Ben Wing.
  4.    Copyright (C) 1995 Sun Microsystems.
  5.  
  6. This file is part of XEmacs.
  7.  
  8. XEmacs is free software; you can redistribute it and/or modify it
  9. under the terms of the GNU General Public License as published by the
  10. Free Software Foundation; either version 2, or (at your option) any
  11. later version.
  12.  
  13. XEmacs is distributed in the hope that it will be useful, but WITHOUT
  14. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with XEmacs; see the file COPYING.  If not, write to the Free
  20. Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21.  
  22. /* Synched up with: FSF 19.28. */
  23.  
  24. /* This file has been Mule-ized except for the frame-title stuff. */
  25.  
  26. #include <config.h>
  27. #include "lisp.h"
  28.  
  29. #include "buffer.h"             /* for Vbuffer_alist */
  30. #include "device.h"
  31. #include "extents.h"
  32. #include "faces.h"
  33. #include "frame.h"
  34. #include "glyphs.h"
  35. #include "redisplay.h"
  36. #include "scrollbar.h"
  37. #include "window.h"
  38.  
  39. #include <errno.h>
  40. #include "sysdep.h"
  41.  
  42. Lisp_Object Vdefault_minibuffer_frame;
  43.  
  44. Lisp_Object Vcreate_frame_hook, Qcreate_frame_hook;
  45. Lisp_Object Vdelete_frame_hook, Qdelete_frame_hook;
  46. Lisp_Object Vmouse_enter_frame_hook, Qmouse_enter_frame_hook;
  47. Lisp_Object Vmouse_leave_frame_hook, Qmouse_leave_frame_hook;
  48. Lisp_Object Vmap_frame_hook, Qmap_frame_hook;
  49. Lisp_Object Vunmap_frame_hook, Qunmap_frame_hook;
  50. Lisp_Object Vmouse_motion_handler;
  51. Lisp_Object Vsynchronize_minibuffers;
  52.  
  53. Lisp_Object Qframep, Qframe_live_p;
  54. Lisp_Object Qframe_x_p, Qframe_tty_p;
  55. Lisp_Object Qdelete_frame;
  56.  
  57. Lisp_Object Vframe_title_format;
  58. Lisp_Object Vframe_icon_title_format;
  59.  
  60. Lisp_Object Qselect_frame_hook, Qdeselect_frame_hook;
  61.  
  62. Lisp_Object Vdefault_frame_name;
  63. Lisp_Object Vdefault_frame_alist;
  64.  
  65. /* If this is non-nil, it is the frame that make-frame is currently
  66.    creating.  We can't set the current frame to this in case the
  67.    debugger goes off because it would try and display to it.  However,
  68.    there are some places which need to reference it which have no
  69.    other way of getting it if it isn't the selected frame. */
  70. Lisp_Object Vframe_being_created;
  71.  
  72.  
  73. static Lisp_Object mark_frame (Lisp_Object, void (*) (Lisp_Object));
  74. static void print_frame (Lisp_Object, Lisp_Object, int);
  75. DEFINE_LRECORD_IMPLEMENTATION ("frame", frame,
  76.                                mark_frame, print_frame, 0, 0, 0,
  77.                    struct frame);
  78.  
  79. static Lisp_Object
  80. mark_frame (Lisp_Object obj, void (*markobj) (Lisp_Object))
  81. {
  82.   struct frame *f = XFRAME (obj);
  83.   ((markobj) (f->device));
  84.   ((markobj) (f->name));
  85.   ((markobj) (f->root_window));
  86.   ((markobj) (f->selected_window));
  87.   ((markobj) (f->minibuffer_window));
  88.   ((markobj) (f->buffer_alist));
  89.   ((markobj) (f->pointer));
  90.   ((markobj) (f->scrollbar_pointer));
  91.   ((markobj) (f->menubar_data));
  92.   ((markobj) (f->toolbar_data[0]));
  93.   ((markobj) (f->toolbar_data[1]));
  94.   ((markobj) (f->toolbar_data[2]));
  95.   ((markobj) (f->toolbar_data[3]));
  96.  
  97.   ((markobj) (f->scrollbar_width));
  98.   ((markobj) (f->scrollbar_height));
  99.  
  100.   ((markobj) (f->toolbar_size[0]));
  101.   ((markobj) (f->toolbar_size[1]));
  102.   ((markobj) (f->toolbar_size[2]));
  103.   ((markobj) (f->toolbar_size[3]));
  104.  
  105.   ((markobj) (f->left_margin_width));
  106.   ((markobj) (f->right_margin_width));
  107.  
  108.   if (!NILP (f->device)) /* device is nil for a dead frame */
  109.     {
  110.       MAYBE_FRAMEMETH (f, mark_frame, (f, markobj));
  111.     }
  112.  
  113.  
  114.   return Qnil;
  115. }
  116.  
  117. static void
  118. print_frame (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
  119. {
  120.   struct frame *frm = XFRAME (obj);
  121.   char buf[200];
  122.   
  123.   if (print_readably)
  124.     error ("printing unreadable object #<frame %s 0x%x>",
  125.            string_data (XSTRING (frm->name)), frm->header.uid);
  126.  
  127.   sprintf (buf, "#<%s-frame ", !FRAME_LIVE_P (frm) ? "dead" :
  128.        DEVICE_TYPE_NAME (XDEVICE (FRAME_DEVICE (frm))));
  129.   write_c_string (buf, printcharfun);
  130.   print_internal (frm->name, printcharfun, 1);
  131.   sprintf (buf, " 0x%x>", frm->header.uid);
  132.   write_c_string (buf, printcharfun);
  133. }
  134.  
  135.  
  136. static struct frame *
  137. allocate_frame (Lisp_Object device, int mini_p)
  138. {
  139.   /* This function can GC */
  140.   Lisp_Object frame = Qnil;
  141.   Lisp_Object root_window;
  142.   Lisp_Object mini_window;
  143.   struct frame *f = alloc_lcrecord (sizeof (struct frame), lrecord_frame);
  144.  
  145.   zero_lcrecord (f);
  146.   XSETFRAME (frame, f);
  147.  
  148.   f->device = device;
  149.   f->name = Qnil;
  150.   f->root_window = Qnil;
  151.   f->selected_window = Qnil;
  152.   f->minibuffer_window = Qnil;
  153.   f->buffer_alist = Fcopy_sequence (Vbuffer_alist);
  154.   f->pointer = Qnil;
  155.   f->scrollbar_pointer = Qnil;
  156.   f->menubar_data = Qnil;
  157.   f->toolbar_data[0] = Qnil;
  158.   f->toolbar_data[1] = Qnil;
  159.   f->toolbar_data[2] = Qnil;
  160.   f->toolbar_data[3] = Qnil;
  161.   f->scrollbar_width = Qnil;
  162.   f->scrollbar_height = Qnil;
  163.   f->toolbar_size[0] = Qnil;
  164.   f->toolbar_size[1] = Qnil;
  165.   f->toolbar_size[2] = Qnil;
  166.   f->toolbar_size[3] = Qnil;
  167.   f->left_margin_width = Qnil;
  168.   f->right_margin_width = Qnil;
  169.   f->has_minibuffer = mini_p;
  170.  
  171.   root_window = allocate_window ();
  172.  
  173.   if (mini_p)
  174.     {
  175.       mini_window = allocate_window ();
  176.       XWINDOW (root_window)->next = mini_window;
  177.       XWINDOW (mini_window)->prev = root_window;
  178.       XWINDOW (mini_window)->mini_p = Qt;
  179.       XWINDOW (mini_window)->frame = frame;
  180.       f->minibuffer_window = mini_window;
  181.     }
  182.   else
  183.     {
  184.       mini_window = Qnil;
  185.       XWINDOW (root_window)->next = root_window;
  186.       XWINDOW (root_window)->prev = root_window;
  187.       f->minibuffer_window = Qnil;
  188.     }
  189.  
  190.   XWINDOW (root_window)->frame = frame;
  191.  
  192.   /* 10 is arbitrary,
  193.      just so that there is "something there."
  194.      Correct size will be set up later with change_frame_size.  */
  195.  
  196.   f->width = 10;
  197.   f->height = 10;
  198.  
  199.   XWINDOW (root_window)->pixel_width = 10;
  200.   XWINDOW (root_window)->pixel_height = ((mini_p) ? 9 : 10);
  201.  
  202.   /* The size of the minibuffer window is now set in x_create_frame
  203.      in xfns.c. */
  204.  
  205.   f->root_window = root_window;
  206.   f->selected_window = root_window;
  207.  
  208.   /* Choose a buffer for the frame's root window.  */
  209.   XWINDOW (root_window)->buffer = Qt;
  210.   {
  211.     Lisp_Object buf;
  212.  
  213.     buf = Fcurrent_buffer ();
  214.     /* If buf is a 'hidden' buffer (i.e. one whose name starts with
  215.        a space), try to find another one.  */
  216.     if (string_char (XSTRING (Fbuffer_name (buf)), 0) == ' ')
  217.       buf = Fother_buffer (buf, Qnil, Qnil);
  218.     Fset_window_buffer (root_window, buf);
  219.   }
  220.  
  221.   if (mini_p)
  222.     {
  223.       XWINDOW (mini_window)->buffer = Qt;
  224.       Fset_window_buffer (mini_window, Vminibuffer_zero);
  225.     }
  226.   update_frame_window_mirror (f);
  227.  
  228.   return f;
  229. }
  230.  
  231. #if 0 /* Unused */
  232. /* Make a frame using a separate minibuffer window on another frame.
  233.    MINI_WINDOW is the minibuffer window to use.  nil means use the
  234.    default (the global minibuffer).  */
  235.  
  236. static struct frame *
  237. allocate_frame_without_minibuffer (Lisp_Object device, Lisp_Object mini_window)
  238. {
  239.   /* This function can GC */
  240.   struct frame *f;
  241.  
  242.   /* Choose the minibuffer window to use.  */
  243.   if (NILP (mini_window))
  244.     {
  245.       over:
  246.       if (!FRAMEP (Vdefault_minibuffer_frame))
  247.     {
  248.       error ("`default-minibuffer-frame' must be set when creating minibufferless frames");
  249.       goto over;
  250.     }
  251.       if (!FRAME_LIVE_P (XFRAME (Vdefault_minibuffer_frame)))
  252.     {
  253.       error ("`default-minibuffer-frame' must be a live frame");
  254.       goto over;
  255.     }
  256.       mini_window = XFRAME (Vdefault_minibuffer_frame)->minibuffer_window;
  257.     }
  258.   else
  259.     {
  260.       CHECK_LIVE_WINDOW (mini_window, 0);
  261.     }
  262.  
  263.   /* Make a frame containing just a root window.  */
  264.   f = allocate_frame (device, 0);
  265.  
  266.   /* Install the chosen minibuffer window, with proper buffer.  */
  267.   f->minibuffer_window = mini_window;
  268.   Fset_window_buffer (mini_window, Vminibuffer_zero);
  269.   return f;
  270. }
  271. #endif
  272.  
  273. #if 0 /* Unused */
  274. /* Make a frame containing only a minibuffer window.  */
  275.  
  276. static struct frame *
  277. make_minibuffer_frame (Lisp_Object device)
  278. {
  279.   /* This function can GC */
  280.   /* First make a frame containing just a root window, no minibuffer.  */
  281.  
  282.   struct frame *f = allocate_frame (device, 0);
  283.   Lisp_Object mini_window;
  284.   Lisp_Object frame;
  285.  
  286.   XSETFRAME (frame, f);
  287.  
  288.   f->no_split = 1;
  289.   f->has_minibuffer = 1;
  290.  
  291.   /* Now label the root window as also being the minibuffer.
  292.      Avoid infinite looping on the window chain by marking next pointer
  293.      as nil. */
  294.  
  295.   mini_window = f->minibuffer_window = f->root_window;
  296.   XWINDOW (mini_window)->mini_p = Qt;
  297.   XWINDOW (mini_window)->next = Qnil;
  298.   XWINDOW (mini_window)->prev = mini_window;
  299.   XWINDOW (mini_window)->frame = frame;
  300.  
  301.   /* Put the proper buffer in that window.  */
  302.  
  303.   Fset_window_buffer (mini_window, Vminibuffer_zero);
  304.   return f;
  305. }
  306. #endif
  307.  
  308. DEFUN ("make-frame", Fmake_frame, Smake_frame, 0, 2, "",
  309.   "Create a new frame, displaying the current buffer.\n\
  310. \n\
  311. Optional argument PARAMETERS is an alist of parameters for the new\n\
  312. frame.  Specifically, PARAMETERS is a list of pairs, each having one\n\
  313. of the following forms:\n\
  314. \n\
  315.  (name . STRING)       - The frame should be named STRING.\n\
  316.  (height . NUMBER)     - The frame should be NUMBER text lines high.\n\
  317.  (width . NUMBER)      - The frame should be NUMBER columns wide.\n\
  318. \n\
  319. The documentation for the variable `default-x-frame-alist' describes\n\
  320. additional frame parameters that Emacs recognizes for X window frames.")
  321.      (parameters, device)
  322.      Lisp_Object parameters, device;
  323. {
  324. /*
  325.  (minibuffer . t)      - the frame should have a minibuffer
  326.  (minibuffer . nil)    - the frame should have no minibuffer
  327.  (minibuffer . only)   - the frame should contain only a minibuffer
  328.  (minibuffer . WINDOW) - the frame should use WINDOW as its minibuffer window.
  329.  */
  330.   struct frame *f;
  331.   struct device *d;
  332.   Lisp_Object frame = Qnil, name;
  333.   struct gcpro gcpro1;
  334.  
  335.   d = get_device (device);
  336.   XSETDEVICE (device, d);
  337.  
  338.   GCPRO1 (frame);
  339.   f = allocate_frame (device, 1);
  340.   XSETFRAME (Vframe_being_created, f);
  341.  
  342.   if (!NILP (f->minibuffer_window))
  343.     reset_face_cache_elements (XWINDOW (f->minibuffer_window));
  344.   reset_face_cache_elements (XWINDOW (f->root_window));
  345.  
  346.   XSETFRAME (frame, f);
  347.  
  348.   name = Fassq (Qname, parameters);
  349.   if (!NILP (name))
  350.     {
  351.       name = Fcdr (name);
  352.       CHECK_STRING (name, 0);
  353.       f->name = name;
  354.     }
  355.   else if (STRINGP (Vdefault_frame_name))
  356.     f->name = Vdefault_frame_name;
  357.   else
  358.     f->name = build_string ("emacs");
  359.  
  360.   if (DEVICE_SPECIFIC_FRAME_PARAMS (d))
  361.     /* Put the device-specific params after the more general ones so
  362.        that they override them. */
  363.     parameters = nconc2 (Fcopy_sequence (*DEVICE_SPECIFIC_FRAME_PARAMS (d)),
  364.              parameters);
  365.   parameters = nconc2 (Fcopy_sequence (Vdefault_frame_alist), parameters);
  366.  
  367.   FRAMEMETH (f, init_frame, (f, parameters));
  368.  
  369.   /* This *must* go before the init_*() methods.  Those functions
  370.      call Lisp code, and if any of them causes a warning to be displayed
  371.      and the *Warnings* buffer to be created, it won't get added to
  372.      the frame-specific version of the buffer-alist unless the frame
  373.      is accessible from the device. */
  374.  
  375.   DEVICE_FRAME_LIST (d) = nconc2 (DEVICE_FRAME_LIST (d), Fcons (frame, Qnil));
  376.   RESET_CHANGED_SET_FLAGS;
  377.  
  378.   /* Now make sure that the initial cached values are set correctly.
  379.      Do this after the init_frame method is called because that may
  380.      do things (e.g. create widgets) that are necessary for the
  381.      specifier value-changed methods to work OK. */
  382.   recompute_all_cached_specifiers_in_frame (f);
  383.  
  384.   if (!DEVICE_IS_STREAM (d))
  385.     {
  386.       init_frame_faces (f);
  387.  
  388.       /* Finish up resourcing the scrollbars. */
  389.       init_frame_scrollbars (f);
  390.  
  391.       /* Create the initial toolbars.  We have to do this after the frame
  392.      methods are called because it may potentially call some things itself
  393.      which depend on the normal frame methods having initialized
  394.      things. */
  395.       init_frame_toolbars (f);
  396.  
  397.       reset_face_cache_elements (XWINDOW (FRAME_SELECTED_WINDOW (f)));
  398.       reset_glyph_cache_elements (XWINDOW (FRAME_SELECTED_WINDOW (f)));
  399.       change_frame_size (f, f->height, f->width, 0, 0);
  400.     }
  401.  
  402.   MAYBE_FRAMEMETH (f, finish_init_frame, (f, parameters));
  403.  
  404.   /* If this is the first frame on the device, make it the selected one. */
  405.   if (NILP (DEVICE_SELECTED_FRAME (d)))
  406.     DEVICE_SELECTED_FRAME (d) = frame;
  407.  
  408.   /* If at startup or if the current device is a stream device
  409.      (usually also at startup), make this device the selected one
  410.      so that messages show up on it. */
  411.   if (NILP (Fselected_device ()) ||
  412.       DEVICE_IS_STREAM (XDEVICE (Fselected_device ())))
  413.     Fselect_device (device);
  414.  
  415.   run_hook_with_args (Qcreate_frame_hook, 1, frame);
  416.  
  417.   Vframe_being_created = Qnil;
  418.  
  419.   UNGCPRO;
  420.   return frame;
  421. }
  422.  
  423.  
  424. /* this function should be used in most cases when a Lisp function is passed
  425.    a FRAME argument.  Use this unless you don't accept nil == current frame
  426.    (in which case, do a CHECK_LIVE_FRAME() and then an XFRAME()) or you
  427.    allow dead frames.  Note that very few functions should accept dead
  428.    frames.  It could be argued that functions should just do nothing when
  429.    given a dead frame, but the presence of a dead frame usually indicates
  430.    an oversight in the Lisp code that could potentially lead to strange
  431.    results and so it is better to catch the error early.
  432.  
  433.    If you only accept X frames, use get_x_frame(), which does what this
  434.    function does but also makes sure the frame is an X frame. */
  435.  
  436. struct frame *
  437. get_frame (Lisp_Object frame)
  438. {
  439.   if (NILP (frame))
  440.     return selected_frame ();
  441.   else
  442.     {
  443.       CHECK_LIVE_FRAME (frame, 0);
  444.       return (XFRAME (frame));
  445.     }
  446. }
  447.  
  448.  
  449. /*
  450.  * window size changes are held up during critical regions.  Afterwards,
  451.  * we want to deal with any delayed changes.
  452.  */
  453. void
  454. hold_frame_size_changes (void)
  455. {
  456.   in_display = 1;
  457. }
  458.  
  459. void
  460. unhold_frame_size_changes (struct frame *f)
  461. {
  462.   in_display = 0;
  463.  
  464.   if (f->size_change_pending)
  465.     change_frame_size (f, f->new_height, f->new_width, 1, 0);
  466. }
  467.  
  468.  
  469.  
  470. DEFUN ("framep", Fframep, Sframep, 1, 1, 0,
  471.   "Return non-nil if OBJECT is a frame.")
  472.   (object)
  473.      Lisp_Object object;
  474. {
  475.   if (!FRAMEP (object))
  476.     return Qnil;
  477.   return Qt;
  478. }
  479.  
  480. DEFUN ("frame-type", Fframe_type, Sframe_type, 1, 1, 0,
  481.   "Return the type of the specified frame (e.g. `x' or `tty').\n\
  482. This is equivalent to the type of the frame's device.\n\
  483. Value is `tty' for a tty frame (a character-only terminal),\n\
  484. `x' for a frame that is an X window,\n\
  485. `stream' for a stream frame (which acts like a stdio stream), and\n\
  486. `dead' for a deleted frame.")
  487.   (frame)
  488.      Lisp_Object frame;
  489. {
  490.   struct frame *f;
  491.  
  492.   CHECK_FRAME (frame, 0);
  493.   f = XFRAME (frame);
  494.  
  495.   return (DEVICE_TYPE (XDEVICE (FRAME_DEVICE (f))));
  496. }
  497.  
  498. DEFUN ("frame-live-p", Fframe_live_p, Sframe_live_p, 1, 1, 0,
  499.   "Return non-nil if OBJECT is a frame which has not been deleted.")
  500.   (object)
  501.      Lisp_Object object;
  502. {
  503.   if (FRAMEP (object) && FRAME_LIVE_P (XFRAME (object)))
  504.     return Qt;
  505.   return Qnil;
  506. }
  507.  
  508.  
  509. /* Called from Fselect_window() */
  510. void
  511. select_frame_1 (Lisp_Object frame)
  512. {
  513.   struct frame *f = XFRAME (frame);
  514.   Lisp_Object old_selected_frame = Fselected_frame (Qnil);
  515.   
  516.   if (EQ (frame, old_selected_frame))
  517.     return;
  518.  
  519.   /* now select the frame's device */
  520.   DEVICE_SELECTED_FRAME (XDEVICE (FRAME_DEVICE (f))) = frame;
  521.   select_device_1 (FRAME_DEVICE (f));
  522.  
  523.   choose_minibuf_frame ();
  524.   update_frame_window_mirror (f);
  525. }
  526.  
  527. DEFUN ("select-frame", Fselect_frame, Sselect_frame, 1, 1, 0,
  528.   "Select the frame FRAME.\n\
  529. Subsequent editing commands apply to its selected window.\n\
  530. The selection of FRAME lasts until the next time the user does\n\
  531. something to select a different frame, or until the next time this\n\
  532. function is called.\n\
  533. \n\
  534. Note that this does not actually cause the window-system focus to\n\
  535. be set to this frame, or the select-frame-hook or deselect-frame-hook\n\
  536. to be run, until the next time that XEmacs is waiting for an event.")
  537.   (frame)
  538.      Lisp_Object frame;
  539. {
  540.   CHECK_LIVE_FRAME (frame, 0);
  541.  
  542.   /* select the frame's selected window.  This will call
  543.      selected_frame_1(). */
  544.   Fselect_window (FRAME_SELECTED_WINDOW (XFRAME (frame)));
  545.  
  546.   /* Nothing should be depending on the return value of this function.
  547.      But, of course, there is stuff out there which is. */
  548.   return frame;
  549. }
  550.  
  551. /* use this to retrieve the currently selected frame.  You should use
  552.    this in preference to Fselected_frame (Qnil) unless you are prepared
  553.    to handle the possibility of there being no selected frame (this
  554.    happens at some points during startup). */
  555.  
  556. struct frame *
  557. selected_frame (void)
  558. {
  559.   Lisp_Object device = Fselected_device ();
  560.   Lisp_Object frame = XDEVICE (device)->selected_frame;
  561.   if (NILP (frame))
  562.     signal_simple_error ("No frames exist on device", device);
  563.   return XFRAME (frame);
  564. }
  565.  
  566. /* use this instead of XFRAME (DEVICE_SELECTED_FRAME (d)) to catch
  567.    the possibility of there being no frames on the device (just created).
  568.    There is no point doing this inside of redisplay because errors
  569.    cause an abort(), indicating a flaw in the logic, and error_check_frame()
  570.    will catch this just as well. */
  571.  
  572. struct frame *
  573. device_selected_frame (struct device *d)
  574. {
  575.   Lisp_Object frame = d->selected_frame;
  576.   if (NILP (frame))
  577.     {
  578.       Lisp_Object device;
  579.       XSETDEVICE (device, d);
  580.       signal_simple_error ("No frames exist on device", device);
  581.     }
  582.   return XFRAME (frame);
  583. }
  584.   
  585. DEFUN ("selected-frame", Fselected_frame, Sselected_frame, 0, 1, 0,
  586.   "Return the frame that is now selected on device DEVICE.\n\
  587. If DEVICE is not specified, the selected device will be used.\n\
  588. If no frames exist on the device, nil is returned.")
  589.   (device)
  590.      Lisp_Object device;
  591. {
  592.   if (NILP (device) && NILP (Fselected_device ()))
  593.     return Qnil; /* happens early in temacs */
  594.   return get_device (device)->selected_frame;
  595. }
  596.  
  597. DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,
  598.        "Return the root-window of FRAME.\n\
  599. If omitted, FRAME defaults to the currently selected frame.")
  600.   (frame)
  601.      Lisp_Object frame;
  602. {
  603.   return (FRAME_ROOT_WINDOW (get_frame (frame)));
  604. }
  605.  
  606. DEFUN ("frame-selected-window", Fframe_selected_window,
  607.        Sframe_selected_window, 0, 1, 0,
  608.   "Return the selected window of frame object FRAME.\n\
  609. If omitted, FRAME defaults to the currently selected frame.")
  610.   (frame)
  611.      Lisp_Object frame;
  612. {
  613.   return (FRAME_SELECTED_WINDOW (get_frame (frame)));
  614. }
  615.  
  616.  
  617. DEFUN ("set-frame-selected-window", Fset_frame_selected_window,
  618.        Sset_frame_selected_window, 2, 2, 0,
  619.   "Set the selected window of frame object FRAME to WINDOW.\n\
  620. If FRAME is nil, the selected frame is used.\n\
  621. If FRAME is the selected frame, this makes WINDOW the selected window.")
  622.   (frame, window)
  623.      Lisp_Object frame, window;
  624. {
  625.   XSETFRAME (frame, get_frame (frame));
  626.   CHECK_LIVE_WINDOW (window, 1);
  627.  
  628.   if (! EQ (frame, WINDOW_FRAME (XWINDOW (window))))
  629.     error ("In `set-frame-selected-window', WINDOW is not on FRAME");
  630.  
  631.   if (XFRAME (frame) == selected_frame ())
  632.     return Fselect_window (window);
  633.  
  634.   return XFRAME (frame)->selected_window = window;
  635. }
  636.  
  637.  
  638. #define LOW_HIGH_WINDOW_LOOP_FOR_BODY                    \
  639.   do                                    \
  640.     {                                    \
  641.       Lisp_Object retval;                        \
  642.                                     \
  643.       w = XWINDOW (win);                        \
  644.       if (!NILP (w->vchild))                        \
  645.     {                                \
  646.       retval = low_high_window_loop (w->vchild, lowest, count, 1);    \
  647.       if (*count == 0)                        \
  648.         return retval;                        \
  649.     }                                \
  650.       else if (!NILP (w->hchild))                    \
  651.     {                                \
  652.       retval = low_high_window_loop (w->hchild, lowest, count, 0);    \
  653.       if (*count == 0)                        \
  654.         return retval;                        \
  655.     }                                \
  656.       else                                \
  657.     {                                \
  658.       if (*count < 0)                        \
  659.         *count += 1;                        \
  660.       else                                \
  661.         *count -= 1;                        \
  662.                                     \
  663.       if (*count == 0)                        \
  664.         return win;                            \
  665.     }                                \
  666.     } while (0)
  667.  
  668. static Lisp_Object
  669. low_high_window_loop (Lisp_Object window, int lowest, int *count,
  670.               int vertical)
  671. {
  672.   struct window *w;
  673.  
  674.   assert (!NILP (window));
  675.  
  676.   if (vertical)
  677.     {
  678.       Lisp_Object win = window;
  679.  
  680.       if (lowest)
  681.     {
  682.       while (!NILP (XWINDOW (win)->next))
  683.         win = XWINDOW (win)->next;
  684.     }
  685.  
  686.       w = XWINDOW (win);
  687.       if (!NILP (w->vchild))
  688.     {
  689.       return low_high_window_loop (w->vchild, lowest,count, 1);
  690.     }
  691.       else if (!NILP (w->hchild))
  692.     {
  693.       return low_high_window_loop (w->hchild, lowest, count, 0);
  694.     }
  695.       else
  696.     {
  697.       if (*count < 0)
  698.         *count += 1;
  699.       else
  700.         *count -= 1;
  701.       
  702.       if (*count == 0)
  703.         return win;
  704.     }
  705.     }
  706.   else
  707.     {
  708.       Lisp_Object win;
  709.  
  710.       if (*count > 0)
  711.     {
  712.       for (win = window; !NILP (win); win = XWINDOW (win)->next)
  713.         {
  714.           LOW_HIGH_WINDOW_LOOP_FOR_BODY;
  715.         }
  716.     }
  717.       else
  718.     {
  719.       Lisp_Object start = window;
  720.       while (!NILP (XWINDOW (start)->next))
  721.         start = XWINDOW (start)->next;
  722.  
  723.       for (win = start; !NILP (win); win = XWINDOW (win)->prev)
  724.         {
  725.           LOW_HIGH_WINDOW_LOOP_FOR_BODY;
  726.         }
  727.     }
  728.     }
  729.  
  730.   return Qnil;
  731. }
  732. #undef LOW_HIGH_WINDOW_LOOP_FOR_BODY
  733.  
  734. static Lisp_Object
  735. low_high_window_internal (struct frame *f, Lisp_Object position, int lowest)
  736. {
  737.   int count;
  738.   struct window *w = XWINDOW (f->root_window);
  739.  
  740.   /* Our internal function uses different values of position.  For it 0
  741.      is a 'found state', the left position starts at 1 and the right
  742.      position starts at -1.  We need to adjust the users position values
  743.      to match. */
  744.  
  745.   if (NILP (position))
  746.     count = 1;
  747.   else
  748.     {
  749.       /* We already verified the type in the calling routines. */
  750.       count = XINT (position);
  751.       if (count >= 0)
  752.     count++;
  753.     }
  754.  
  755.   if (!NILP (w->vchild))
  756.     return low_high_window_loop (w->vchild, lowest, &count, 1);
  757.   else if (!NILP (w->hchild))
  758.     return low_high_window_loop (w->hchild, lowest, &count, 0);
  759.   else if (count == 1 || count == -1)
  760.     return f->root_window;
  761.   else
  762.     return Qnil;
  763. }
  764.  
  765. /* DO NOT change the fact that the return value is nil if POSITION would
  766.    be a window off the frame edge.  Doing so will lead to an infinite
  767.    loop in the Fwindow_{highest,lowest}-p functions. */
  768.  
  769. DEFUN ("frame-lowest-window", Fframe_lowest_window, Sframe_lowest_window,
  770.        0, 2, 0,
  771.   "Return the lowest window on FRAME which is at POSITION.\n\
  772. If omitted, FRAME defaults to the currently selected frame.\n\
  773. If omitted, POSITION defaults to 0 which is the leftmost lowest window.\n\
  774. If POSITION is negative, it is considered to start from the right.\n\
  775. The rightmost lowest window has a position of -1.\n\
  776. If there is no window at the given POSITION, return nil.")
  777.      (frame, position)
  778.      Lisp_Object frame, position;
  779. {
  780.   struct frame *f = get_frame (frame);
  781.  
  782.   if (!NILP (position))
  783.     CHECK_INT (position, 0);
  784.  
  785.   return low_high_window_internal (f, position, 1);
  786. }
  787.  
  788. DEFUN ("frame-highest-window", Fframe_highest_window, Sframe_highest_window,
  789.        0, 2, 0,
  790.   "Return the highest window on FRAME which is at POSITION.\n\
  791. If omitted, FRAME defaults to the currently selected frame.\n\
  792. If omitted, POSITION defaults to 0 which is the leftmost highest window.\n\
  793. If POSITION is negative, it is considered to start from the right.\n\
  794. The rightmost highest window has a position of -1.\n\
  795. If there is no window at the given POSITION, return nil.")
  796.      (frame, position)
  797.      Lisp_Object frame, position;
  798. {
  799.   struct frame *f = get_frame (frame);
  800.  
  801.   if (!NILP (position))
  802.     CHECK_INT (position, 0);
  803.  
  804.   return low_high_window_internal (f, position, 0);
  805. }
  806.  
  807.  
  808. DEFUN ("frame-device", Fframe_device, Sframe_device,
  809.        0, 1, 0,
  810.        "Return the device that FRAME is on.\n\
  811. If omitted, FRAME defaults to the currently selected frame.")
  812.      (frame)
  813.      Lisp_Object frame;
  814. {
  815.   return (FRAME_DEVICE (get_frame (frame)));
  816. }
  817.  
  818. /* Return the next frame in the frame list after FRAME.
  819.    If MINIBUF is nil, exclude minibuffer-only frames.
  820.    If MINIBUF is a window, include only its own frame
  821.    and any frame now using that window as the minibuffer.
  822.    If MINIBUF is `visible', include all visible frames.
  823.    If MINIBUF is 0, include all visible and iconified frames.
  824.    Otherwise, include all frames.  */
  825.  
  826. Lisp_Object
  827. next_frame (Lisp_Object frame, Lisp_Object minibuf)
  828. {
  829.   Lisp_Object tail;
  830.   int passed = 0;
  831.   Lisp_Object frame_list;
  832.  
  833.   /* If this frame is dead, it won't be in frame_list, and we'll loop
  834.      forever.  Forestall that.  */
  835.   CHECK_LIVE_FRAME (frame, 0);
  836.  
  837.   /* There must always be at least one frame in frame_list.  */
  838.   frame_list = DEVICE_FRAME_LIST (XDEVICE (FRAME_DEVICE (XFRAME (frame))));
  839.   assert (!NILP (frame_list));
  840.  
  841.   while (1)
  842.     for (tail = frame_list; CONSP (tail); tail = XCDR (tail))
  843.       {
  844.     Lisp_Object f;
  845.     struct frame *fr;
  846.  
  847.     f = XCAR (tail);
  848.     fr = XFRAME (f);
  849.     if (passed)
  850.       {
  851.         /* Decide whether this frame is eligible to be returned.  */
  852.  
  853.         /* If we've looped all the way around without finding any
  854.            eligible frames, return the original frame.  */
  855.         if (EQ (f, frame))
  856.           return f;
  857.  
  858.         /* Let minibuf decide if this frame is acceptable.  */
  859.         if (NILP (minibuf))
  860.           {
  861.         if (! FRAME_MINIBUF_ONLY_P (fr))
  862.           return f;
  863.           }
  864.         else if (EQ (minibuf, Qvisible))
  865.           {
  866. #if 0 /* FSFmacs */
  867.         FRAME_SAMPLE_VISIBILITY (fr);
  868. #endif
  869.         if (FRAME_VISIBLE_P (fr))
  870.           return f;
  871.           }
  872.         else if (EQ (minibuf, Qzero))
  873.           {
  874. #if 0 /* FSFmacs */
  875.         FRAME_SAMPLE_VISIBILITY (fr);
  876. #endif
  877.         if (FRAME_VISIBLE_P (fr)
  878.             || FRAME_ICONIFIED_P (fr))
  879.           return f;
  880.           }
  881.         else if (WINDOWP (minibuf))
  882.           {
  883.         if (EQ (FRAME_MINIBUF_WINDOW (fr), minibuf)
  884.             /* Check that F either is, or has forwarded its focus to,
  885.                MINIBUF's frame.  */
  886.             && (EQ (WINDOW_FRAME (XWINDOW (minibuf)), f)
  887. #if 0 /* FSFmacs */
  888.             || EQ (WINDOW_FRAME (XWINDOW (minibuf)),
  889.                    FRAME_FOCUS_FRAME (fr))
  890. #endif
  891.             ))
  892.           return f;
  893.           }
  894.         else
  895.           return f;
  896.       }
  897.  
  898.     if (EQ (frame, f))
  899.       passed++;
  900.       }
  901. }
  902.  
  903.  
  904. /* Return the previous frame in the frame list before FRAME.
  905.    If MINIBUF is nil, exclude minibuffer-only frames.
  906.    If MINIBUF is a window, include only its own frame
  907.    and any frame now using that window as the minibuffer.
  908.    If MINIBUF is `visible', include all visible frames.
  909.    If MINIBUF is 0, include all visible and iconified frames.
  910.    Otherwise, include all frames.  */
  911.  
  912. Lisp_Object
  913. prev_frame (Lisp_Object frame, Lisp_Object minibuf)
  914. {
  915.   Lisp_Object tail;
  916.   Lisp_Object prev;
  917.   Lisp_Object frame_list;
  918.  
  919.   /* If this frame is dead, it won't be in frame_list, and we'll loop
  920.      forever.  Forestall that.  */
  921.   CHECK_LIVE_FRAME (frame, 0);
  922.  
  923.   /* There must always be at least one frame in frame_list.  */
  924.   frame_list = DEVICE_FRAME_LIST (XDEVICE (FRAME_DEVICE (XFRAME (frame))));
  925.   assert (!NILP (frame_list));
  926.  
  927.   prev = Qnil;
  928.   for (tail = frame_list; CONSP (tail); tail = XCDR (tail))
  929.     {
  930.       Lisp_Object f;
  931.       struct frame *fr;
  932.  
  933.       f = XCAR (tail);
  934.       fr = XFRAME (f);
  935.  
  936.       if (EQ (frame, f) && !NILP (prev))
  937.     return prev;
  938.  
  939.       /* Decide whether this frame is eligible to be returned,
  940.      according to minibuf.  */
  941.       if (NILP (minibuf))
  942.     {
  943.       if (! FRAME_MINIBUF_ONLY_P (fr))
  944.         prev = f;
  945.     }
  946.       else if (WINDOWP (minibuf))
  947.     {
  948.       if (EQ (FRAME_MINIBUF_WINDOW (fr), minibuf)
  949.           /* Check that F either is, or has forwarded its focus to,
  950.          MINIBUF's frame.  */
  951.           && (EQ (WINDOW_FRAME (XWINDOW (minibuf)), f)
  952. #if 0 /* FSFmacs */
  953.           || EQ (WINDOW_FRAME (XWINDOW (minibuf)),
  954.              FRAME_FOCUS_FRAME (fr))
  955. #endif
  956.           ))
  957.         prev = f;
  958.     }
  959.       else if (EQ (minibuf, Qvisible))
  960.     {
  961. #if 0 /* FSFmacs */
  962.       FRAME_SAMPLE_VISIBILITY (fr);
  963. #endif
  964.       if (FRAME_VISIBLE_P (fr))
  965.         prev = f;
  966.     }
  967.       else if (EQ (minibuf, Qzero)) 
  968.     {
  969. #if 0 /* FSFmacs */
  970.       FRAME_SAMPLE_VISIBILITY (fr);
  971. #endif
  972.       if (FRAME_VISIBLE_P (fr)
  973.           || FRAME_ICONIFIED_P (fr))
  974.         prev = f;
  975.     }
  976.       else
  977.     prev = f;
  978.     }
  979.  
  980.   /* We've scanned the entire list.  */
  981.   if (NILP (prev))
  982.     /* We went through the whole frame list without finding a single
  983.        acceptable frame.  Return the original frame.  */
  984.     return frame;
  985.   else
  986.     /* There were no acceptable frames in the list before FRAME; otherwise,
  987.        we would have returned directly from the loop.  Since PREV is the last
  988.        acceptable frame in the list, return it.  */
  989.     return prev;
  990. }
  991.  
  992. DEFUN ("next-frame", Fnext_frame, Snext_frame,
  993.        0, 2, 0,
  994.   "Return the next frame in the frame list after FRAME.\n\
  995. By default, skip minibuffer-only frames.\n\
  996. If omitted, FRAME defaults to the selected frame.\n\
  997. If optional argument MINIBUF is nil, exclude minibuffer-only frames.\n\
  998. If MINIBUF is a window, include only its own frame\n\
  999. and any frame now using that window as the minibuffer.\n\
  1000. If MINIBUF is `visible', include all visible frames.\n\
  1001. If MINIBUF is 0, include all visible and iconified frames.\n\
  1002. Otherwise, include all frames.")
  1003.   (frame, minibuf)
  1004.      Lisp_Object frame, minibuf;
  1005. {
  1006.   XSETFRAME (frame, get_frame (frame));
  1007.  
  1008.   return (next_frame (frame, minibuf));
  1009. }
  1010.  
  1011. DEFUN ("previous-frame", Fprevious_frame, Sprevious_frame,
  1012.        0, 2, 0,
  1013.   "Return the previous frame in the frame list before FRAME.\n\
  1014. By default, skip minibuffer-only frames.\n\
  1015. If omitted, FRAME defaults to the selected frame.\n\
  1016. If optional argument MINIBUF is nil, exclude minibuffer-only frames.\n\
  1017. If MINIBUF is a window, include only its own frame\n\
  1018. and any frame now using that window as the minibuffer.\n\
  1019. If MINIBUF is `visible', include all visible frames.\n\
  1020. If MINIBUF is 0, include all visible and iconified frames.\n\
  1021. Otherwise, include all frames.")
  1022.   (frame, minibuf)
  1023.      Lisp_Object frame, minibuf;
  1024. {
  1025.   XSETFRAME (frame, get_frame (frame));
  1026.  
  1027.   return (prev_frame (frame, minibuf));
  1028. }
  1029.  
  1030.  
  1031. extern void free_window_mirror (struct window_mirror *mir);
  1032. extern void free_line_insertion_deletion_costs (struct frame *f);
  1033.  
  1034.      /* In FSF, delete-frame will not normally allow you to delete
  1035.         the last visible frame.  You have to specify the FORCE argument
  1036.     to get this behavior.  In XEmacs, this restriction was removed
  1037.     because it was too annoying. */
  1038.  
  1039. /* Return 1 if it is ok to delete frame F;
  1040.    0 if all frames aside from F are invisible.
  1041.    (Exception: if F is the terminal frame, and we are using X, return 1.)  */
  1042.  
  1043. int
  1044. other_visible_frames (struct frame *f)
  1045. {
  1046.   Lisp_Object frame_list;
  1047.   frame_list = DEVICE_FRAME_LIST (XDEVICE (FRAME_DEVICE (f)));
  1048.  
  1049.   /* We know the selected frame is visible,
  1050.      so if F is some other frame, it can't be the sole visible one.  */
  1051.   if (f == selected_frame ())
  1052.     {
  1053.       Lisp_Object frames;
  1054.       int count = 0;
  1055.  
  1056.       for (frames = frame_list;
  1057.        CONSP (frames);
  1058.        frames = XCDR (frames))
  1059.     {
  1060.       Lisp_Object this;
  1061.  
  1062.       this = XCAR (frames);
  1063.       /* Verify that the frame's window still exists
  1064.          and we can still talk to it.  And note any recent change
  1065.          in visibility.  */
  1066.  
  1067.       if (FRAME_VISIBLE_P (XFRAME (this))
  1068.           || FRAME_ICONIFIED_P (XFRAME (this))
  1069. #ifdef HAVE_WINDOW_SYSTEM
  1070.           /* Allow deleting the initial terminal frame when at least
  1071.          one window system frame exists!  */
  1072.           || (FRAME_IS_WIN (XFRAME (this)) && !FRAME_IS_WIN (f))
  1073. #endif /* HAVE_WINDOW_SYSTEM */
  1074.           )
  1075.         count++;
  1076.     }
  1077.       return count > 1;
  1078.     }
  1079.   return 1;
  1080. }
  1081.  
  1082. void
  1083. delete_frame_internal (Lisp_Object frame, int ok_to_delete_last)
  1084. {
  1085.   /* This function can GC */
  1086.   struct frame *f;
  1087.   struct device *d;
  1088.  
  1089.   if (NILP (frame))
  1090.     {
  1091.       f = selected_frame ();
  1092.       XSETFRAME (frame, f);
  1093.     }
  1094.   else
  1095.     {
  1096.       CHECK_FRAME (frame, 0);
  1097.       f = XFRAME (frame);
  1098.     }
  1099.  
  1100.   /* OK to delete an already deleted frame. */
  1101.   if (! FRAME_LIVE_P (f))
  1102.     return;
  1103.  
  1104.   d = XDEVICE (f->device);
  1105.  
  1106. #if 0
  1107.   /* Does this frame have a minibuffer, and is it the surrogate
  1108.      minibuffer for any other frame?  */
  1109.   if (FRAME_HAS_MINIBUF_P (f))
  1110.     {
  1111.       Lisp_Object frames;
  1112.  
  1113.       for (frames = Vframe_list;
  1114.        CONSP (frames);
  1115.        frames = XCDR (frames))
  1116.     {
  1117.       Lisp_Object this = XCAR (frames);
  1118.  
  1119.       if (! EQ (this, frame)
  1120.           && EQ (frame,
  1121.              (WINDOW_FRAME
  1122.               (XWINDOW
  1123.                (FRAME_MINIBUF_WINDOW
  1124.             (XFRAME (this)))))))
  1125.         signal_simple_error
  1126.           ("Attempt to delete a surrogate minibuffer frame",
  1127.            frame);
  1128.     }
  1129.     }
  1130. #endif
  1131.  
  1132.   /* If we were focussed on this frame, then we're not any more.
  1133.      Assume that we lost the focus; that way, the call to
  1134.      Fselect_frame() below won't end up making us explicitly
  1135.      focus on another frame, which is generally undesirable in
  1136.      a point-to-type world.  If our mouse ends up sitting over
  1137.      another frame, we will receive a FocusIn event and end up
  1138.      making that frame the selected frame.
  1139.  
  1140.      #### This may not be an ideal solution in a click-to-type
  1141.      world (in that case, we might want to explicitly choose
  1142.      another frame to have the focus, rather than relying on
  1143.      the WM, which might focus on a frame in a different app
  1144.      or focus on nothing at all).  But there's no easy way
  1145.      to detect which focus model we're running on, and the
  1146.      alternative is more heinous. */
  1147.  
  1148.   if (EQ (frame, DEVICE_FRAME_WITH_FOCUS (d)))
  1149.     DEVICE_FRAME_WITH_FOCUS (d) = Qnil;
  1150.   if (EQ (frame, DEVICE_FRAME_THAT_OUGHT_TO_HAVE_FOCUS (d)))
  1151.     DEVICE_FRAME_THAT_OUGHT_TO_HAVE_FOCUS (d) = Qnil;
  1152.  
  1153.   /* Don't allow deleted frame to remain selected.
  1154.      Note that in the former scheme of things, this would
  1155.      have caused us to regain the focus.  This no longer
  1156.      applies (see above); I think the new behavior is more
  1157.      logical.  If someone disagrees, it can always be
  1158.      changed (or a new user variable can be introduced,
  1159.      ugh.) */
  1160.   if (EQ (frame, DEVICE_SELECTED_FRAME (d)))
  1161.     {
  1162.       Lisp_Object next;
  1163.  
  1164.       next = next_frame (frame, Qvisible);
  1165.       if (EQ (next, frame))
  1166.     {
  1167.       Lisp_Object invisible_next = next_frame (frame, Qt);
  1168.       if (EQ (frame, invisible_next))
  1169.         {
  1170.           if (!ok_to_delete_last)
  1171.         signal_simple_error
  1172.           ("Attempt to delete the only frame", frame);
  1173.         }
  1174.       else
  1175.         next = invisible_next;
  1176.     }
  1177.  
  1178.       if (d == XDEVICE (Fselected_device ()))
  1179.     Fselect_frame (next);
  1180.       else
  1181.     DEVICE_SELECTED_FRAME (d) = next;
  1182.     }
  1183.  
  1184.   /* Don't allow minibuf_window to remain on a deleted frame.  */
  1185.   if (EQ (f->minibuffer_window, minibuf_window))
  1186.     {
  1187.       struct frame *sel_frame = selected_frame ();
  1188.       Fset_window_buffer (sel_frame->minibuffer_window,
  1189.               XWINDOW (minibuf_window)->buffer);
  1190.       minibuf_window = sel_frame->minibuffer_window;
  1191.     }
  1192.  
  1193.   /* Before here, we haven't made any dangerous changed (just checked for
  1194.      error conditions).  Now run the delete-frame-hook.  Remember that
  1195.      user code there could do any number of dangerous things, including
  1196.      signalling an error.
  1197.    */
  1198.  
  1199.   run_hook_with_args (Qdelete_frame_hook, 1, frame);
  1200.  
  1201.   /* After this point, no errors must be allowed to occur. */
  1202.  
  1203.   /* This must be done before the window and window_mirror structures
  1204.      are freed.  The scrollbar information is attached to them. */
  1205.   MAYBE_FRAMEMETH (f, delete_frame, (f));
  1206.  
  1207.   /* Mark all the windows that used to be on FRAME as deleted, and then
  1208.      remove the reference to them.  */
  1209.   delete_all_subwindows (XWINDOW (f->root_window));
  1210.   f->root_window = Qnil;
  1211.  
  1212.   /* Remove the frame now from the list.  This way, any events generated
  1213.      on this frame by the maneuvers below will disperse themselves.
  1214.    */
  1215.  
  1216.   {
  1217.     struct device *d = XDEVICE (FRAME_DEVICE (f));
  1218.  
  1219.     /* This used to be Fdelq(), but that will cause a seg fault if the
  1220.        QUIT checker happens to get invoked, because the frame list is
  1221.        in an inconsistent state */
  1222.     d->frame_list = delq_no_quit (frame, d->frame_list);
  1223.     RESET_CHANGED_SET_FLAGS;
  1224.   }
  1225.  
  1226.   f->dead = 1;
  1227.   f->visible = 0;
  1228.  
  1229.   free_window_mirror (f->root_mirror);
  1230. /*  free_line_insertion_deletion_costs (f); */
  1231.  
  1232.   f->device = Qnil; /* nobody should be accessing the device any more. */
  1233.  
  1234. #if 0
  1235.   /* If we've deleted the last_nonminibuf_frame, then try to find
  1236.      another one.  */
  1237.   if (f == last_nonminibuf_frame)
  1238.     {
  1239.       Lisp_Object frames;
  1240.  
  1241.       last_nonminibuf_frame = 0;
  1242.  
  1243.       for (frames = Vframe_list;
  1244.        CONSP (frames);
  1245.        frames = XCDR (frames))
  1246.     {
  1247.       f = XFRAME (XCAR (frames));
  1248.       if (!FRAME_MINIBUF_ONLY_P (f))
  1249.         {
  1250.           last_nonminibuf_frame = f;
  1251.           break;
  1252.         }
  1253.     }
  1254.     }
  1255.  
  1256.   /* If we've deleted Vdefault_minibuffer_frame, try to find another
  1257.      one.  Prefer minibuffer-only frames, but also notice frames
  1258.      with other windows.  */
  1259.   if (EQ (frame, Vdefault_minibuffer_frame))
  1260.     {
  1261.       Lisp_Object frames;
  1262.  
  1263.       /* The last frame we saw with a minibuffer, minibuffer-only or not.  */
  1264.       Lisp_Object frame_with_minibuf = Qnil;
  1265.  
  1266.       for (frames = Vframe_list;
  1267.        CONSP (frames);
  1268.        frames = XCDR (frames))
  1269.     {
  1270.       Lisp_Object this = XCAR (frames);
  1271.  
  1272.       f = XFRAME (this);
  1273.  
  1274.       if (FRAME_HAS_MINIBUF_P (f))
  1275.         {
  1276.           frame_with_minibuf = this;
  1277.           if (FRAME_MINIBUF_ONLY_P (f))
  1278.         break;
  1279.         }
  1280.     }
  1281.  
  1282.       /* We know that there must be some frame with a minibuffer out
  1283.      there.  If this were not true, all of the frames present
  1284.      would have to be minibufferless, which implies that at some
  1285.      point their minibuffer frames must have been deleted, but
  1286.      that is prohibited at the top; you can't delete surrogate
  1287.      minibuffer frames.  */
  1288.       assert (!NILP (frame_with_minibuf));
  1289.  
  1290.       Vdefault_minibuffer_frame = frame_with_minibuf;
  1291.     }
  1292. #endif
  1293.  
  1294.   return;
  1295. }
  1296.  
  1297. DEFUN ("delete-frame", Fdelete_frame, Sdelete_frame,
  1298.        0, 2, "",
  1299.        "Delete FRAME, permanently eliminating it from use.\n\
  1300. If omitted, FRAME defaults to the selected frame.\n\
  1301. A frame may not be deleted if its minibuffer is used by other frames.")
  1302.      (frame, ignored)
  1303.      Lisp_Object frame, ignored;
  1304. {
  1305.   /* This function can GC */
  1306.   delete_frame_internal (frame, 0);
  1307.   return Qnil;
  1308. }
  1309.  
  1310.  
  1311. /* Return mouse position in character cell units.  */
  1312.  
  1313. DEFUN ("mouse-position", Fmouse_position, Smouse_position, 0, 1, 0,
  1314.   "Return a list (WINDOW X . Y) giving the current mouse window and position.\n\
  1315. The position is given in character cells, where (0, 0) is the\n\
  1316. upper-left corner of the window.\n\
  1317. \n\
  1318. DEVICE specifies the device on which to read the mouse position, and\n\
  1319. defaults to the selected device.  If the device is a mouseless terminal\n\
  1320. or Emacs hasn't been programmed to read its mouse position, it returns\n\
  1321. the device's selected window for WINDOW and nil for X and Y.")
  1322.      (device)
  1323.      Lisp_Object device;
  1324. {
  1325.   Lisp_Object val = Fmouse_pixel_position (device);
  1326.   int x, y, obj_x, obj_y;
  1327.   struct window *w;
  1328.   struct frame *f;
  1329.   Bufpos bufpos, closest;
  1330.   Lisp_Object class;
  1331.  
  1332.   if (NILP (XCAR (val)) || NILP (XCAR (XCDR (val))))
  1333.     return val;
  1334.   w = XWINDOW (XCAR (val));
  1335.   x = XINT (XCAR (XCDR (val)));
  1336.   y = XINT (XCDR (XCDR (val)));
  1337.   f = XFRAME (w->frame);
  1338.  
  1339.   if (x >= 0 && y >= 0 &&
  1340.       pixel_to_glyph_translation (f, x, y, &x, &y, &obj_x, &obj_y, &w,
  1341.                   &bufpos, &closest, &class) != OVER_NOTHING)
  1342.     {
  1343.       XCAR (XCDR (val)) = make_number (x);
  1344.       XCDR (XCDR (val)) = make_number (y);
  1345.     }
  1346.   else
  1347.     {
  1348.       XCAR (XCDR (val)) = Qnil;
  1349.       XCDR (XCDR (val)) = Qnil;
  1350.     }
  1351.  
  1352.   return val;
  1353. }
  1354.  
  1355. DEFUN ("mouse-pixel-position", Fmouse_pixel_position,
  1356.        Smouse_pixel_position, 0, 1, 0,
  1357.   "Return a list (WINDOW X . Y) giving the current mouse window and position.\n\
  1358. The position is given in pixel units, where (0, 0) is the\n\
  1359. upper-left corner.\n\
  1360. \n\
  1361. DEVICE specifies the device on which to read the mouse position, and\n\
  1362. defaults to the selected device.  If the device is a mouseless terminal\n\
  1363. or Emacs hasn't been programmed to read its mouse position, it returns\n\
  1364. the device's selected window for FRAME and nil for X and Y.")
  1365.      (device)
  1366.      Lisp_Object device;
  1367. {
  1368.   struct device *d = get_device (device);
  1369.   struct frame *f = device_selected_frame (d);
  1370.   struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
  1371.   Lisp_Object window;
  1372.   Lisp_Object x, y;
  1373.   int intx, inty;
  1374.  
  1375.   x = y = Qnil;
  1376.   XSETWINDOW (window, w);
  1377.  
  1378.   switch (DEVMETH_OR_GIVEN (d, get_mouse_position, (d, &w, &intx, &inty), -1))
  1379.     {
  1380.     case 1:
  1381.       XSETINT (x, intx);
  1382.       XSETINT (y, inty);
  1383.       XSETWINDOW (window, w);
  1384.       break;
  1385.     case 0:
  1386.       window = Qnil;
  1387.       break;
  1388.     case -1:
  1389.       break;
  1390.     default:
  1391.       abort (); /* hook is incorrectly written */
  1392.     }
  1393.  
  1394.   return Fcons (window, Fcons (x, y));
  1395. }
  1396.  
  1397. DEFUN ("set-mouse-position", Fset_mouse_position, Sset_mouse_position, 3, 3, 0,
  1398.   "Move the mouse pointer to the center of character cell (X,Y) in WINDOW.")
  1399.      (window, x, y)
  1400.      Lisp_Object window, x, y;
  1401. {
  1402.   struct window *w;
  1403.   int pix_x, pix_y;
  1404.  
  1405.   CHECK_WINDOW (window, 0);
  1406.   CHECK_INT (x, 2);
  1407.   CHECK_INT (y, 1);
  1408.  
  1409.   /* Warping the mouse will cause EnterNotify and Focus events under X. */
  1410.   w = XWINDOW (window);
  1411.   glyph_to_pixel_translation (w, XINT (x), XINT (y), &pix_x, &pix_y);
  1412.  
  1413.   MAYBE_FRAMEMETH (XFRAME (w->frame), set_mouse_position, (w, pix_x, pix_y));
  1414.  
  1415.   return Qnil;
  1416. }
  1417.  
  1418. DEFUN ("set-mouse-pixel-position", Fset_mouse_pixel_position,
  1419.        Sset_mouse_pixel_position, 3, 3, 0,
  1420.   "Move the mouse pointer to pixel position (X,Y) in WINDOW.")
  1421.      (window, x, y)
  1422.      Lisp_Object window, x, y;
  1423. {
  1424.   struct window *w;
  1425.  
  1426.   CHECK_WINDOW (window, 0);
  1427.   CHECK_INT (x, 2);
  1428.   CHECK_INT (y, 1);
  1429.  
  1430.   /* Warping the mouse will cause EnterNotify and Focus events under X. */
  1431.   w = XWINDOW (window);
  1432.   FRAMEMETH (XFRAME (w->frame), set_mouse_position, (w, XINT (x), XINT (y)));
  1433.  
  1434.   return Qnil;
  1435. }
  1436.  
  1437. #if 0
  1438. /* ??? Can this be replaced with a Lisp function? */
  1439.  
  1440. DEFUN ("frame-configuration", Fframe_configuration, Sframe_configuration,
  1441.        0, 0, 0,
  1442.   "Return object describing current frame configuration.\n\
  1443. The frame configuration is the current mouse position and selected frame.\n\
  1444. This object can be given to `restore-frame-configuration'\n\
  1445. to restore this frame configuration.")
  1446.   ()
  1447. {
  1448.   int x, y;
  1449.   Lisp_Object c, frame;
  1450.   struct frame *f;
  1451.   
  1452.   c = make_vector (3, Qnil);
  1453.   vector_data (XVECTOR (c))[0] = frame = Fselected_frame (Qnil);
  1454.   read_mouse_position (frame, &x, &y);
  1455.   vector_data (XVECTOR (c))[1] = make_number (x);
  1456.   vector_data (XVECTOR (c))[2] = make_number (y);
  1457.  
  1458.   return c;
  1459. }
  1460.  
  1461. DEFUN ("restore-frame-configuration", Frestore_frame_configuration,
  1462.        Srestore_frame_configuration,
  1463.        1, 1, 0,
  1464.   "Restores frame configuration CONFIGURATION.")
  1465.   (config)
  1466.   Lisp_Object config;
  1467. {
  1468.   Lisp_Object x_pos, y_pos, frame;
  1469.  
  1470.   CHECK_VECTOR (config, 0);
  1471.   if (XVECTOR (config)->size != 3)
  1472.     {
  1473.       signal_simple_error
  1474.     ("Wrong size vector passed to restore-frame-configuration",
  1475.      config);
  1476.     }
  1477.   frame = vector_data (XVECTOR (config))[0];
  1478.   /* select-frame will error on dead frame */
  1479.   CHECK_FRAME (frame, 0);
  1480.  
  1481.   Fselect_frame (frame);
  1482.  
  1483.   return frame;
  1484. }    
  1485. #endif
  1486.  
  1487. DEFUN ("make-frame-visible", Fmake_frame_visible, Smake_frame_visible,
  1488.        0, 1, 0,
  1489.   "Make the frame FRAME visible (assuming it is an X-window).\n\
  1490. If omitted, FRAME defaults to the currently selected frame.\n\
  1491. Also raises the frame so that nothing obscures it.")
  1492.      (frame)
  1493.      Lisp_Object frame;
  1494. {
  1495.   struct frame *f = get_frame (frame);
  1496.  
  1497.   MAYBE_FRAMEMETH (f, make_frame_visible, (f));
  1498.   return frame;
  1499. }
  1500.  
  1501. DEFUN ("make-frame-invisible", Fmake_frame_invisible, Smake_frame_invisible,
  1502.        0, 2, 0,
  1503.   "Unconditionally removes frame from the display (assuming it is an X-window).\n\
  1504. If omitted, FRAME defaults to the currently selected frame.\n\
  1505. If what you want to do is iconify the frame (if the window manager uses\n\
  1506. icons) then you should call `iconify-frame' instead.")
  1507.      (frame, ignored)
  1508.      Lisp_Object frame, ignored;
  1509. {
  1510.   struct frame *f, *sel_frame;
  1511.   struct device *d;
  1512.  
  1513.   f = get_frame (frame);
  1514.   d = XDEVICE (FRAME_DEVICE (f));
  1515.   sel_frame = XFRAME (DEVICE_SELECTED_FRAME (d));
  1516.  
  1517. #if 0 /* FSFmacs */
  1518.   if (NILP (force) && !other_visible_frames (f))
  1519.     error ("Attempt to make invisible the sole visible or iconified frame");
  1520. #endif
  1521.  
  1522.   /* Don't allow minibuf_window to remain on a deleted frame.  */
  1523.   if (EQ (f->minibuffer_window, minibuf_window))
  1524.     {
  1525.       Fset_window_buffer (sel_frame->minibuffer_window,
  1526.               XWINDOW (minibuf_window)->buffer);
  1527.       minibuf_window = sel_frame->minibuffer_window;
  1528.     }
  1529.  
  1530.   MAYBE_FRAMEMETH (f, make_frame_invisible, (f));
  1531.  
  1532.   return Qnil;
  1533. }
  1534.  
  1535. DEFUN ("iconify-frame", Ficonify_frame, Siconify_frame,
  1536.        0, 1, "",
  1537.  "Make the frame FRAME into an icon, if the window manager supports icons.\n\
  1538. If omitted, FRAME defaults to the currently selected frame.")
  1539.   (frame)
  1540.      Lisp_Object frame;
  1541. {
  1542.   struct frame *f, *sel_frame;
  1543.   struct device *d;
  1544.  
  1545.   f = get_frame (frame);
  1546.   d = XDEVICE (FRAME_DEVICE (f));
  1547.   sel_frame = XFRAME (DEVICE_SELECTED_FRAME (d));
  1548.  
  1549.   /* Don't allow minibuf_window to remain on a deleted frame.  */
  1550.   if (EQ (f->minibuffer_window, minibuf_window))
  1551.     {
  1552.       Fset_window_buffer (sel_frame->minibuffer_window,
  1553.               XWINDOW (minibuf_window)->buffer);
  1554.       minibuf_window = sel_frame->minibuffer_window;
  1555.     }
  1556.  
  1557.   MAYBE_FRAMEMETH (f, iconify_frame, (f));
  1558.  
  1559.   return Qnil;
  1560. }
  1561.  
  1562. DEFUN ("deiconify-frame", Fdeiconify_frame, Sdeiconify_frame,
  1563.        0, 1, 0,
  1564.   "Open (de-iconify) the iconified frame FRAME.\n\
  1565. Under X, this is currently the same as `make-frame-visible'.\n\
  1566. If omitted, FRAME defaults to the currently selected frame.\n\
  1567. Also raises the frame so that nothing obscures it.")
  1568.   (frame)
  1569.      Lisp_Object frame;
  1570. {
  1571.   return Fmake_frame_visible (frame);
  1572. }
  1573.  
  1574. /* FSF returns 'icon for iconized frames.  What a crock! */
  1575.  
  1576. DEFUN ("frame-visible-p", Fframe_visible_p, Sframe_visible_p,
  1577.        1, 1, 0,
  1578.        "Return t if FRAME is now \"visible\" (actually in use for display).\n\
  1579. A frame that is not visible is not updated, and, if it works through a\n\
  1580. window system, may not show at all.")
  1581.   (frame)
  1582.      Lisp_Object frame;
  1583. {
  1584.   CHECK_LIVE_FRAME (frame, 0);
  1585.   return (XFRAME (frame)->visible ? Qt : Qnil);
  1586. }
  1587.  
  1588. DEFUN ("frame-totally-visible-p", Fframe_totally_visible_p,
  1589.        Sframe_totally_visible_p, 0, 1, 0,
  1590.   "Return T if frame is not obscured by any other X windows, NIL otherwise.\n\
  1591. Always returns t for tty frames.")
  1592.   (frame)
  1593.      Lisp_Object frame;
  1594. {
  1595.   struct frame *f = get_frame (frame);
  1596.   /* #### does it make sense that tty frames are always "totally visible"?
  1597.      I think this should be changed so that tty frames are totally visible
  1598.      if and only if they're visible, i.e. they're the currently active
  1599.      frame. */
  1600.   return (FRAMEMETH_OR_GIVEN (f, frame_totally_visible_p, (f), 1) ? Qt : Qnil);
  1601. }
  1602.  
  1603. DEFUN ("frame-iconified-p", Fframe_iconified_p, Sframe_iconified_p,
  1604.        1, 1, 0,
  1605.        "Return t if FRAME is iconified.\n\
  1606. Not all window managers use icons; some merely unmap the window, so this\n\
  1607. function is not the inverse of `frame-visible-p'.  It is possible for a\n\
  1608. frame to not be visible and not be iconified either.  However, if the\n\
  1609. frame is iconified, it will not be visible.")
  1610.   (frame)
  1611.      Lisp_Object frame;
  1612. {
  1613.   struct frame *f = get_frame (frame);
  1614.   if (f->visible)
  1615.     return Qnil;
  1616.   f->iconified = FRAMEMETH_OR_GIVEN (f, frame_iconified_p, (f), 0);
  1617.   return (f->iconified ? Qt : Qnil);
  1618. }
  1619.  
  1620. DEFUN ("visible-frame-list", Fvisible_frame_list, Svisible_frame_list,
  1621.        0, 1, 0,
  1622.        "Return a list of all frames now \"visible\" (being updated).\n\
  1623. If DEVICE is specified only frames on that device will be returned.")
  1624.   (device)
  1625.      Lisp_Object device;
  1626. {
  1627.   Lisp_Object tail, frame, dev;
  1628.   struct frame *f;
  1629.   Lisp_Object value;
  1630.  
  1631.   value = Qnil;
  1632.  
  1633.   DEVICE_LOOP (dev)
  1634.     {
  1635.       assert (DEVICEP (XCAR (dev)));
  1636.  
  1637.       if (NILP (device) || EQ (device, XCAR (dev)))
  1638.     {
  1639.       for (tail = DEVICE_FRAME_LIST (XDEVICE (XCAR (dev)));
  1640.            !NILP (tail);
  1641.            tail = XCDR (tail))
  1642.         {
  1643.           frame = XCAR (tail);
  1644.           if (!FRAMEP (frame))
  1645.         continue;
  1646.           f = XFRAME (frame);
  1647.           if (f->visible)
  1648.         value = Fcons (frame, value);
  1649.         }
  1650.     }
  1651.     }
  1652.  
  1653.   return value;
  1654. }
  1655.  
  1656.  
  1657. DEFUN ("raise-frame", Fraise_frame, Sraise_frame, 0, 1, "",
  1658.   "Bring FRAME to the front, so it occludes any frames it overlaps.\n\
  1659. If omitted, FRAME defaults to the currently selected frame.\n\
  1660. If FRAME is invisible, make it visible.\n\
  1661. If Emacs is displaying on an ordinary terminal or some other device which\n\
  1662. doesn't support multiple overlapping frames, this function does nothing.")
  1663.   (frame)
  1664.      Lisp_Object frame;
  1665. {
  1666.   struct frame *f = get_frame (frame);
  1667.  
  1668.   /* Do like the documentation says. */
  1669.   Fmake_frame_visible (frame);
  1670.   MAYBE_FRAMEMETH (f, raise_frame, (f));
  1671.   return Qnil;
  1672. }
  1673.  
  1674. DEFUN ("lower-frame", Flower_frame, Slower_frame, 0, 1, "",
  1675.   "Send FRAME to the back, so it is occluded by any frames that overlap it.\n\
  1676. If omitted, FRAME defaults to the currently selected frame.\n\
  1677. If Emacs is displaying on an ordinary terminal or some other device which\n\
  1678. doesn't support multiple overlapping frames, this function does nothing.")
  1679.   (frame)
  1680.      Lisp_Object frame;
  1681. {
  1682.   struct frame *f = get_frame (frame);
  1683.  
  1684.   MAYBE_FRAMEMETH (f, lower_frame, (f));
  1685.   return Qnil;
  1686. }
  1687.  
  1688.  
  1689.  
  1690. void
  1691. store_in_alist (Lisp_Object *alistptr, CONST char *propname, Lisp_Object val)
  1692. {
  1693.   Lisp_Object tem;
  1694.   Lisp_Object prop;
  1695.  
  1696.   prop = intern (propname);
  1697.   tem = assq_no_quit (prop, *alistptr);
  1698.   if (EQ (tem, Qnil))
  1699.     *alistptr = Fcons (Fcons (prop, val), *alistptr);
  1700.   else
  1701.     Fsetcdr (tem, val);
  1702. }
  1703.  
  1704. #if 0
  1705.  
  1706. /* #### this function is not used and should be deleted.
  1707.    However, there may be some potentially useful code in
  1708.    the surrogate-minibuffer shit below. */
  1709.  
  1710. void
  1711. store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
  1712. {
  1713.   Lisp_Object tem;
  1714.  
  1715.   tem = assq_no_quit (prop, f->param_alist);
  1716.   if (EQ (tem, Qnil))
  1717.     f->param_alist = Fcons (Fcons (prop, val), f->param_alist);
  1718.   else
  1719.     Fsetcdr (tem, val);
  1720.  
  1721. #if 0
  1722.   if (EQ (prop, Qminibuffer)
  1723.       && WINDOWP (val))
  1724.     {
  1725.       if (! MINI_WINDOW_P (XWINDOW (val)))
  1726.     signal_simple_error
  1727.       ("Surrogate minibuffer windows must be minibuffer windows.",
  1728.        val);
  1729.  
  1730.       if (FRAME_HAS_MINIBUF_P (f) || FRAME_MINIBUF_ONLY_P (f))
  1731.     {
  1732.       Lisp_Object frame;
  1733.       XSETFRAME (frame, f);
  1734.       signal_simple_error
  1735.         ("Can't change the surrogate minibuffer of a frame with its own minibuffer.", frame);
  1736.     }
  1737.  
  1738.       /* Install the chosen minibuffer window, with proper buffer.  */
  1739.       f->minibuffer_window = val;
  1740.     }
  1741. #endif
  1742. }
  1743.  
  1744. #endif
  1745.  
  1746. DEFUN ("frame-parameters", Fframe_parameters, Sframe_parameters, 0, 1, 0,
  1747.   "Return the parameters-alist of frame FRAME.\n\
  1748. It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.\n\
  1749. The meaningful PARMs depend on the kind of frame.\n\
  1750. If FRAME is omitted, return information on the currently selected frame.\n\
  1751. \n\
  1752. See the variables `default-frame-alist', `default-x-frame-alist', and\n\
  1753. `default-tty-frame-alist' for a description of the parameters meaningful\n\
  1754. for particular types of frames.")
  1755.   (frame)
  1756.      Lisp_Object frame;
  1757. {
  1758.   Lisp_Object alist = Qnil;
  1759.   struct frame *f = get_frame (frame);
  1760.  
  1761.   store_in_alist (&alist, "name", f->name);
  1762.   store_in_alist (&alist, "height", make_number (FRAME_HEIGHT (f)));
  1763.   store_in_alist (&alist, "width", make_number (FRAME_WIDTH (f)));
  1764.   store_in_alist (&alist, "minibuffer", (FRAME_HAS_MINIBUF_P (f) 
  1765. #if 0
  1766.                                          ? Qnone
  1767.                                          : (FRAME_MINIBUF_ONLY_P (f) ? Qonly
  1768.                                             : FRAME_MINIBUF_WINDOW (f))
  1769. #else
  1770.                                          ? FRAME_MINIBUF_WINDOW (f) : Qnil
  1771. #endif
  1772.                                          ));
  1773.   store_in_alist (&alist, "unsplittable", (FRAME_NO_SPLIT_P (f)
  1774.                                            ? Qt : Qnil));
  1775.   /* #### serious overhaulage needs to be applied to the following. */
  1776.   store_in_alist (&alist, "pointer", f->pointer);
  1777.   store_in_alist (&alist, "scrollbar-pointer", f->scrollbar_pointer);
  1778.  
  1779.   MAYBE_FRAMEMETH (f, get_frame_params, (f, &alist));
  1780.   return alist;
  1781. }
  1782.  
  1783. /* #### Using this to modify the internal border width has no effect
  1784.    because the change isn't propagated to the windows.  Are there
  1785.    other parameters which this claims to handle, but doesn't? */
  1786. DEFUN ("modify-frame-parameters", Fmodify_frame_parameters, 
  1787.        Smodify_frame_parameters, 2, 2, 0,
  1788.   "Modify the parameters of frame FRAME according to ALIST.\n\
  1789. ALIST is an alist of parameters to change and their new values.\n\
  1790. Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.\n\
  1791. The meaningful PARMs depend on the kind of frame; undefined PARMs are\n\
  1792. ignored.\n\
  1793. \n\
  1794. See the variables `default-frame-alist', `default-x-frame-alist', and\n\
  1795. `default-tty-frame-alist' for a description of the parameters recognized\n\
  1796. for particular types of frames.")
  1797.   (frame, alist)
  1798.      Lisp_Object frame, alist;
  1799. {
  1800.   struct frame *f = get_frame (frame);
  1801.  
  1802.   MAYBE_FRAMEMETH (f, set_frame_params, (f, alist));
  1803.   return Qnil;
  1804. }
  1805.  
  1806. /* #### These could be written in Lisp
  1807.  * ####  (defun frame-height (f) (cdr (assq 'height (frame-parameters s))))
  1808.  * But they shouldn't be; frame-parameters should be replaced with
  1809.  * a frame plist or something.
  1810.  */
  1811.  
  1812. DEFUN ("frame-height", Fframe_height, Sframe_height, 0, 1, 0,
  1813.   "Return number of lines available for display on FRAME.")
  1814.   (frame)
  1815.      Lisp_Object frame;
  1816. {
  1817.   return (make_number (FRAME_HEIGHT (get_frame (frame))));
  1818. }
  1819.  
  1820. DEFUN ("frame-width", Fframe_width, Sframe_width, 0, 1, 0,
  1821.   "Return number of columns available for display on FRAME.")
  1822.   (frame)
  1823.      Lisp_Object frame;
  1824. {
  1825.   return (make_number (FRAME_WIDTH (get_frame (frame))));
  1826. }
  1827.  
  1828. DEFUN ("frame-pixel-height", Fframe_pixel_height, Sframe_pixel_height, 0, 1, 0,
  1829.   "Return the height in pixels of FRAME.")
  1830.   (frame)
  1831.      Lisp_Object frame;
  1832. {
  1833.   struct frame *f = get_frame (frame);
  1834.   return (make_number (f->pixheight));
  1835. }
  1836.  
  1837. DEFUN ("frame-pixel-width", Fframe_pixel_width, Sframe_pixel_width, 0, 1, 0,
  1838.   "Return the width in pixels of FRAME.")
  1839.   (frame)
  1840.      Lisp_Object frame;
  1841. {
  1842.   struct frame *f = get_frame (frame);
  1843.   return (make_number (f->pixwidth));
  1844. }
  1845.  
  1846. DEFUN ("frame-name", Fframe_name, Sframe_name, 0, 1, 0,
  1847.        "Return the name of FRAME (defaulting to the selected frame).\n\
  1848. This is not the same as the `title' of the frame.")
  1849.      (frame)
  1850.      Lisp_Object frame;
  1851. {
  1852.   return (get_frame (frame)->name);
  1853. }
  1854.  
  1855.  
  1856. static void
  1857. internal_set_frame_size (struct frame *f, int cols, int rows, int pretend)
  1858. {
  1859.   if (pretend || !HAS_FRAMEMETH_P (f, set_frame_size))
  1860.     change_frame_size (f, rows, cols, pretend, 0);
  1861.   else
  1862.     FRAMEMETH (f, set_frame_size, (f, cols, rows));
  1863. }
  1864.  
  1865. DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 3, 0,
  1866.   "Specify that the frame FRAME has LINES lines.\n\
  1867. Optional third arg non-nil means that redisplay should use LINES lines\n\
  1868. but that the idea of the actual height of the frame should not be changed.")
  1869.   (frame, rows, pretend)
  1870.      Lisp_Object frame, rows, pretend;
  1871. {
  1872.   struct frame *f = get_frame (frame);
  1873.   XSETFRAME (frame, f);
  1874.   CHECK_INT (rows, 1);
  1875.   
  1876.   internal_set_frame_size (f, FRAME_WIDTH (f), XINT (rows), 
  1877.                             !NILP (pretend));
  1878.   return frame;
  1879. }
  1880.  
  1881. DEFUN ("set-frame-width", Fset_frame_width, Sset_frame_width, 2, 3, 0,
  1882.   "Specify that the frame FRAME has COLS columns.\n\
  1883. Optional third arg non-nil means that redisplay should use COLS columns\n\
  1884. but that the idea of the actual width of the frame should not be changed.")
  1885.   (frame, cols, pretend)
  1886.      Lisp_Object frame, cols, pretend;
  1887. {
  1888.   struct frame *f = get_frame (frame);
  1889.   XSETFRAME (frame, f);
  1890.   CHECK_INT (cols, 1);
  1891.  
  1892.   internal_set_frame_size (f, XINT (cols), FRAME_HEIGHT (f),
  1893.                 !NILP (pretend));
  1894.   return frame;
  1895. }
  1896.  
  1897. DEFUN ("set-frame-size", Fset_frame_size, 
  1898.        Sset_frame_size, 3, 4, 0,
  1899.   "Sets size of FRAME to COLS by ROWS.\n\
  1900. Optional fourth arg non-nil means that redisplay should use COLS by ROWS\n\
  1901. but that the idea of the actual size of the frame should not be changed.")
  1902.   (frame, cols, rows, pretend)
  1903.      Lisp_Object frame, cols, rows, pretend;
  1904. {
  1905.   struct frame *f = get_frame (frame);
  1906.   XSETFRAME (frame, f);
  1907.   CHECK_INT (cols, 1);
  1908.   CHECK_INT (rows, 2);
  1909.  
  1910.   internal_set_frame_size (f, XINT (cols), XINT (rows), !NILP (pretend));
  1911.   return frame;
  1912. }
  1913.  
  1914. DEFUN ("set-frame-position", Fset_frame_position, 
  1915.        Sset_frame_position, 3, 3, 0,
  1916.   "Sets position of FRAME in pixels to XOFFSET by YOFFSET.\n\
  1917. This is actually the position of the upper left corner of the frame.\n\
  1918. Negative values for XOFFSET or YOFFSET are interpreted relative to\n\
  1919. the rightmost or bottommost possible position (that stays within the screen).")
  1920.   (frame, xoffset, yoffset)
  1921.      Lisp_Object frame, xoffset, yoffset;
  1922. {
  1923.   struct frame *f = get_frame (frame);
  1924.   CHECK_INT (xoffset, 1);
  1925.   CHECK_INT (yoffset, 2);
  1926.  
  1927.   MAYBE_FRAMEMETH (f, set_frame_position, (f, XINT (xoffset), XINT (yoffset)));
  1928.  
  1929.   return Qt;
  1930. }
  1931.  
  1932. struct frame *
  1933. choose_minibuf_frame (void)
  1934. {
  1935.   struct frame *sel_frame;
  1936.   struct device *d;
  1937.  
  1938.   if (FRAMEP (Vdefault_minibuffer_frame))
  1939.     return XFRAME (Vdefault_minibuffer_frame);
  1940.  
  1941.   d = XDEVICE (Fselected_device ());
  1942.   if (NILP (DEVICE_SELECTED_FRAME (d)))
  1943.     return 0;
  1944.   else
  1945.     sel_frame = XFRAME (DEVICE_SELECTED_FRAME (d));
  1946.  
  1947.   /* For lowest-level minibuf, put it on currently selected frame
  1948.      if frame has a minibuffer.  */
  1949.   if (sel_frame != 0
  1950.       && !EQ (minibuf_window, FRAME_MINIBUF_WINDOW (sel_frame)))
  1951.     {
  1952.       /* I don't think that any frames may validly have a null minibuffer
  1953.      window anymore.  */
  1954.       if (NILP (sel_frame->minibuffer_window))
  1955.     abort ();
  1956.  
  1957.       /* #### This completely screws up point in the minibuffer.  Why
  1958.          is this here. */
  1959. #if 0
  1960.       if (!NILP (minibuf_window)) /* happens at startup */
  1961.     Fset_window_buffer (sel_frame->minibuffer_window,
  1962.                 XWINDOW (minibuf_window)->buffer);
  1963. #endif
  1964.       minibuf_window = sel_frame->minibuffer_window;
  1965.     }
  1966.  
  1967.   return sel_frame;
  1968. }
  1969.  
  1970.  
  1971. /* Change the frame height and/or width.  Values may be given as zero to
  1972.    indicate no change is to take place. */
  1973. static void
  1974. change_frame_size_1 (struct frame *f, int newheight, int newwidth, int pretend)
  1975. {
  1976.   Lisp_Object frame;
  1977.   struct device *d = XDEVICE (f->device);
  1978.   int new_pixheight, new_pixwidth;
  1979.   int font_height, font_width;
  1980.   struct font_metric_info fm;
  1981.  
  1982.   if (in_display)
  1983.     abort ();
  1984.  
  1985.   XSETFRAME (frame, f);
  1986.   DEVMETH (d, font_metric_info, (d, FACE_FONT (Vdefault_face, frame),
  1987.                  &fm));
  1988.   font_height = fm.ascent + fm.descent;
  1989.   font_width = fm.width;
  1990.  
  1991.   /* This size-change overrides any pending one for this frame.  */
  1992.   FRAME_NEW_HEIGHT (f) = 0;
  1993.   FRAME_NEW_WIDTH (f) = 0;
  1994.  
  1995.   new_pixheight = newheight * font_height;
  1996.   new_pixwidth = (newwidth - 1) * font_width;
  1997.  
  1998.   if (!FRAME_IS_TTY (f)) /* #### need abstraction */
  1999.     {
  2000.       new_pixheight += XINT (f->scrollbar_height);
  2001.       new_pixwidth += XINT (f->scrollbar_width);
  2002.     }
  2003.  
  2004.   if (!FRAME_TOP_TOOLBAR_VISIBLE (f))
  2005.     new_pixheight += FRAME_TOP_TOOLBAR_HEIGHT (f);
  2006.   if (!FRAME_BOTTOM_TOOLBAR_VISIBLE (f))
  2007.     new_pixheight += FRAME_BOTTOM_TOOLBAR_HEIGHT (f);
  2008.   if (!FRAME_LEFT_TOOLBAR_VISIBLE (f))
  2009.     new_pixwidth += FRAME_LEFT_TOOLBAR_WIDTH (f);
  2010.   if (!FRAME_RIGHT_TOOLBAR_VISIBLE (f))
  2011.     new_pixwidth += FRAME_RIGHT_TOOLBAR_WIDTH (f);
  2012.  
  2013.   /* Adjust the width for the end glyph which may be a different width
  2014.      than the default character width. */
  2015.   {
  2016.     int adjustment, trunc_width, cont_width;
  2017.  
  2018.     trunc_width = glyph_width (Vtruncation_glyph, DEFAULT_INDEX, 1,
  2019.                    FRAME_SELECTED_WINDOW (f));
  2020.     cont_width = glyph_width (Vcontinuation_glyph, DEFAULT_INDEX, 1,
  2021.                   FRAME_SELECTED_WINDOW (f));
  2022.     adjustment = max (trunc_width, cont_width);
  2023.     adjustment = max (adjustment, font_width);
  2024.  
  2025.     new_pixwidth += adjustment;
  2026.   }
  2027.  
  2028.   /* If we don't have valid values, exit. */
  2029.   if (!new_pixheight && !new_pixwidth)
  2030.     return;
  2031.  
  2032.   /* #### This doesn't take into account a separate minibuffer because
  2033.      we haven't implemented it yet. */
  2034.   if (new_pixheight)
  2035.     {
  2036.       XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_top = FRAME_TOP_BORDER_END (f);
  2037.       set_window_pixheight (FRAME_ROOT_WINDOW (f),
  2038.              new_pixheight - font_height, 0);
  2039.  
  2040.       XWINDOW (FRAME_MINIBUF_WINDOW (f))->pixel_top =
  2041.     new_pixheight - font_height + FRAME_TOP_BORDER_END (f);
  2042.  
  2043.       set_window_pixheight (FRAME_MINIBUF_WINDOW (f), font_height, 0);
  2044.  
  2045.       FRAME_HEIGHT (f) = newheight;
  2046.       if (FRAME_IS_TTY (f))
  2047.     f->pixheight = newheight;
  2048.     }
  2049.  
  2050.   if (new_pixwidth)
  2051.     {
  2052.       XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_left = FRAME_LEFT_BORDER_END (f);
  2053.       set_window_pixwidth (FRAME_ROOT_WINDOW (f), new_pixwidth, 0);
  2054.  
  2055.       XWINDOW (FRAME_MINIBUF_WINDOW (f))->pixel_left =
  2056.            FRAME_LEFT_BORDER_END (f);
  2057.       set_window_pixwidth (FRAME_MINIBUF_WINDOW (f), new_pixwidth, 0);
  2058.  
  2059.       FRAME_WIDTH (f) = newwidth;
  2060.       if (FRAME_IS_TTY (f))
  2061.     f->pixwidth = newwidth;
  2062.     }
  2063.  
  2064.   MARK_FRAME_TOOLBARS_CHANGED (f);
  2065.   MARK_FRAME_CHANGED (f);
  2066. }
  2067.  
  2068. void
  2069. change_frame_size (struct frame *f, int newheight, int newwidth, int pretend,
  2070.            int delay)
  2071. {
  2072.   /* sometimes we get passed a size that's too small (esp. when a
  2073.      client widget gets resized, since we have no control over this).
  2074.      So deal. */
  2075.   check_frame_size (f, &newheight, &newwidth);
  2076.  
  2077.   if (delay || in_display || gc_in_progress)
  2078.     {
  2079.       MARK_FRAME_SIZE_CHANGED (f);
  2080.       f->new_width = newwidth;
  2081.       f->new_height = newheight;
  2082.       return;
  2083.     }
  2084.  
  2085.   f->size_change_pending = 0;
  2086.   change_frame_size_1 (f, newheight, newwidth, pretend);
  2087. }
  2088.  
  2089.  
  2090. #define CONVERT_MODE_STRING_BUFFER        \
  2091.   do {                        \
  2092.     int i;                    \
  2093.     Emchar *s = Dynarr_atp (mode_string_buffer, 0); \
  2094.     int len = Dynarr_length (mode_string_buffer); \
  2095.                         \
  2096.     if (frame_title_string)            \
  2097.       xfree (frame_title_string);        \
  2098.     frame_title_string = (char *) xmalloc ((len + 1) * sizeof (char)); \
  2099.                         \
  2100.     for (i = 0; i < len; i++)            \
  2101.       {                        \
  2102.     /* #### perhaps should use DASSERT? */    \
  2103.     assert (s[i] < 0x100);            \
  2104.     frame_title_string[i] = (char) s[i];    \
  2105.       }                        \
  2106.     frame_title_string[len] = '\0';        \
  2107.   } while (0)
  2108.  
  2109. void
  2110. update_frame_title (struct frame *f)
  2111. {
  2112.   struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
  2113.   Lisp_Object title_format;
  2114.   Lisp_Object icon_format;
  2115.   Lisp_Object old_cur_buf = Fcurrent_buffer ();
  2116.   char *frame_title_string = 0;
  2117.  
  2118.   /* tty's don't display titles */
  2119.   if (FRAME_IS_TTY (f))
  2120.     return;
  2121.  
  2122.   /* We don't change the title for the minibuffer */
  2123.   else if (MINI_WINDOW_P (w))
  2124.     return;
  2125.  
  2126.   /* And we don't want dead buffers to blow up on us. */
  2127.   else if (!BUFFER_LIVE_P (XBUFFER (w->buffer)))
  2128.     return;
  2129.  
  2130.   /* #### Ugh.  See about getting rid of setting the current buffer.
  2131.      It is really so very gross. */
  2132.   Fset_buffer (w->buffer);
  2133.  
  2134.   title_format = Vframe_title_format;
  2135.   icon_format = Vframe_icon_title_format;
  2136.  
  2137.   if (HAS_FRAMEMETH_P (f, set_title_from_char))
  2138.     {
  2139.       Dynarr_reset (mode_string_buffer);
  2140.       generate_modeline_string (w, 0, 0, -1, title_format, 0, -1,
  2141.                 DEFAULT_INDEX, CURRENT_DISP);
  2142.  
  2143.       CONVERT_MODE_STRING_BUFFER;
  2144.       FRAMEMETH (f, set_title_from_char, (f, frame_title_string));
  2145.     }
  2146.  
  2147.   if (HAS_FRAMEMETH_P (f, set_icon_name_from_char))
  2148.     {
  2149.       if (!EQ (icon_format, title_format) ||
  2150.       !HAS_FRAMEMETH_P (f, set_title_from_char))
  2151.     {
  2152.       Dynarr_reset (mode_string_buffer);
  2153.       generate_modeline_string (w, 0, 0, -1, icon_format, 0, -1,
  2154.                     DEFAULT_INDEX, CURRENT_DISP);
  2155.       CONVERT_MODE_STRING_BUFFER;
  2156.     }
  2157.  
  2158.       FRAMEMETH (f, set_icon_name_from_char, (f, frame_title_string));
  2159.     }
  2160.  
  2161.   Fset_buffer (old_cur_buf);
  2162.   if (frame_title_string)
  2163.     xfree (frame_title_string);
  2164. }
  2165.  
  2166.  
  2167. void
  2168. syms_of_frame (void)
  2169. {
  2170.   defsymbol (&Qdelete_frame_hook, "delete-frame-hook");
  2171.   /* defvarred in frame.el */
  2172.   defsymbol (&Qselect_frame_hook, "select-frame-hook");
  2173.   defsymbol (&Qdeselect_frame_hook, "deselect-frame-hook");
  2174.   defsymbol (&Qcreate_frame_hook, "create-frame-hook");
  2175.   defsymbol (&Qmouse_enter_frame_hook, "mouse-enter-frame-hook");
  2176.   defsymbol (&Qmouse_leave_frame_hook, "mouse-leave-frame-hook");
  2177.   defsymbol (&Qmap_frame_hook, "map-frame-hook");
  2178.   defsymbol (&Qunmap_frame_hook, "unmap-frame-hook");
  2179.  
  2180.   defsymbol (&Qframep, "framep");
  2181.   defsymbol (&Qframe_live_p, "frame-live-p");
  2182.   defsymbol (&Qframe_x_p, "frame-x-p");
  2183.   defsymbol (&Qframe_tty_p, "frame-tty-p");
  2184.   defsymbol (&Qdelete_frame, "delete-frame");
  2185.  
  2186.   defsubr (&Smake_frame);
  2187.   defsubr (&Sframep);
  2188.   defsubr (&Sframe_type);
  2189.   defsubr (&Sframe_live_p);
  2190.   defsubr (&Sselect_frame);
  2191.   defsubr (&Sselected_frame);
  2192.   defsubr (&Sframe_root_window);
  2193.   defsubr (&Sframe_selected_window);
  2194.   defsubr (&Sset_frame_selected_window);
  2195.   defsubr (&Sframe_lowest_window);
  2196.   defsubr (&Sframe_highest_window);
  2197.   defsubr (&Sframe_device);
  2198.   defsubr (&Snext_frame);
  2199.   defsubr (&Sprevious_frame);
  2200.   defsubr (&Sdelete_frame);
  2201.   defsubr (&Smouse_position);
  2202.   defsubr (&Smouse_pixel_position);
  2203.   defsubr (&Sset_mouse_position);
  2204.   defsubr (&Sset_mouse_pixel_position);
  2205. #if 0
  2206.   defsubr (&Sframe_configuration);
  2207.   defsubr (&Srestore_frame_configuration);
  2208. #endif
  2209.   defsubr (&Smake_frame_visible);
  2210.   defsubr (&Smake_frame_invisible);
  2211.   defsubr (&Siconify_frame);
  2212.   defsubr (&Sdeiconify_frame);
  2213.   defsubr (&Sframe_visible_p);
  2214.   defsubr (&Sframe_totally_visible_p);
  2215.   defsubr (&Sframe_iconified_p);
  2216.   defsubr (&Svisible_frame_list);
  2217.   defsubr (&Sraise_frame);
  2218.   defsubr (&Slower_frame);
  2219.   defsubr (&Sframe_parameters);
  2220.   defsubr (&Smodify_frame_parameters);
  2221.   defsubr (&Sframe_height);
  2222.   defsubr (&Sframe_width);
  2223.   defsubr (&Sframe_pixel_height);
  2224.   defsubr (&Sframe_pixel_width);
  2225.   defsubr (&Sframe_name);
  2226.   defsubr (&Sset_frame_height);
  2227.   defsubr (&Sset_frame_width);
  2228.   defsubr (&Sset_frame_size);
  2229.   defsubr (&Sset_frame_position);
  2230. }
  2231.  
  2232. void
  2233. vars_of_frame (void)
  2234. {
  2235.   Vframe_being_created = Qnil;
  2236.   staticpro (&Vframe_being_created);
  2237.  
  2238.   DEFVAR_LISP ("default-minibuffer-frame", &Vdefault_minibuffer_frame,
  2239.  "A frame-object holding the default minibuffer for minibufferless frames.\n\
  2240. When you create a minibufferless frame, by default it will use the\n\
  2241. minibuffer of this frame.  It is up to you to create a suitable frame\n\
  2242. and store it in this variable.");
  2243.   Vdefault_minibuffer_frame = Qnil;
  2244.  
  2245.   DEFVAR_LISP ("delete-frame-hook", &Vdelete_frame_hook,
  2246.      "Function or functions to call when a frame is deleted.\n\
  2247. One argument, the to-be-deleted frame.");
  2248.   Vdelete_frame_hook = Qnil;
  2249.  
  2250.   DEFVAR_LISP ("create-frame-hook", &Vcreate_frame_hook,
  2251.      "Function or functions to call when a frame is created.\n\
  2252. One argument, the newly-created frame.");
  2253.   Vcreate_frame_hook = Qnil;
  2254.  
  2255.   DEFVAR_LISP ("mouse-enter-frame-hook", &Vmouse_enter_frame_hook,
  2256.      "Function or functions to call when mouse enters a frame.\n\
  2257. One argument, the frame.\n\
  2258. Be careful not to make assumptions about the window manger's focus model.\n\
  2259. In most cases, the `deselect-frame-hook' is more appropriate.");
  2260.   Vmouse_enter_frame_hook = Qnil;
  2261.  
  2262.   DEFVAR_LISP ("mouse-leave-frame-hook", &Vmouse_leave_frame_hook,
  2263.      "Function or functions to call when mouse leaves frame.\n\
  2264. One argument, the frame.\n\
  2265. Be careful not to make assumptions about the window manger's focus model.\n\
  2266. In most cases, the `select-frame-hook' is more appropriate.");
  2267.   Vmouse_leave_frame_hook = Qnil;
  2268.  
  2269.   DEFVAR_LISP ("map-frame-hook", &Vmap_frame_hook,
  2270.     "Function or functions to call when frame is mapped.\n\
  2271. One argument, the frame.");
  2272.   Vmap_frame_hook = Qnil;
  2273.  
  2274.   DEFVAR_LISP ("unmap-frame-hook", &Vunmap_frame_hook,
  2275.     "Function or functions to call when frame is unmapped.\n\
  2276. One argument, the frame.");
  2277.   Vunmap_frame_hook = Qnil;
  2278.  
  2279.   DEFVAR_LISP ("mouse-motion-handler", &Vmouse_motion_handler,
  2280.     "Handler for motion events.  One arg, the event.\n\
  2281. For most applications, you should use `mode-motion-hook' instead of this.");
  2282.   Vmouse_motion_handler = Qnil;
  2283.  
  2284.   DEFVAR_LISP ("synchronize-minibuffers",&Vsynchronize_minibuffers,
  2285.            "Set to t if all minibuffer windows are to be synchronized.\n\
  2286. This will cause echo area messages to appear in the minibuffers of all\n\
  2287. visible frames.");
  2288.   Vsynchronize_minibuffers = Qnil;
  2289.  
  2290.   DEFVAR_LISP ("frame-title-format", &Vframe_title_format,
  2291.   "Controls the title of the X window corresponding to the selected frame.\n\
  2292. This is the same format as `modeline-format' with the exception that\n\
  2293. %- is ignored.");
  2294.   Vframe_title_format = Fpurecopy (build_string ("%S: %b"));
  2295.  
  2296.   DEFVAR_LISP ("frame-icon-title-format", &Vframe_icon_title_format,
  2297.   "Controls the title of the icon corresponding to the selected frame.\n\
  2298. See also the variable `frame-title-format'");
  2299.   Vframe_icon_title_format = Fpurecopy (build_string ("%b"));
  2300.  
  2301.   DEFVAR_LISP ("default-frame-name", &Vdefault_frame_name,
  2302.     "The default name to assign to newly-created frames.\n\
  2303. This can be overridden by arguments to `make-frame'.\n\
  2304. This must be a string.");
  2305.   Vdefault_frame_name = Fpurecopy (build_string ("emacs"));
  2306.  
  2307.   DEFVAR_LISP ("default-frame-alist", &Vdefault_frame_alist,
  2308.     "Alist of default values for frame creation, other than the first one.\n\
  2309. These may be set in your init file, like this:\n\
  2310. \n\
  2311.   (setq default-frame-alist '((width . 80) (height . 55)))\n\
  2312. \n\
  2313. Since the first X frame is created before loading your .emacs file,\n\
  2314. you must use the X resource database for that.\n\
  2315. \n\
  2316. See also the variables `default-x-frame-alist' and\n\
  2317. `default-tty-frame-alist', which are like `default-frame-alist'\n\
  2318. except that they apply only to X or tty frames, respectively\n\
  2319. (whereas `default-frame-alist' applies to all types of frames).");
  2320.   Vdefault_frame_alist = Qnil;
  2321. }
  2322.  
  2323.